#pragma once

#include <functional>
#include <memory>
#include <vector>
#include <assert.h>
#include <unistd.h>
#include <sys/eventfd.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/syscall.h>
#include <atomic>
#include <mutex>
#include "Logger_v2.hpp"

/**
 * 文件描述符（fd）封装 ：每个 Channel 对应一个 fd（如监听套接字、连接套接字），管理其关注的事件（读、写、错误）及回调函数。
 * 事件分发 ：根据 Poller 返回的就绪事件，调用对应的回调函数。
 */
class Channel {
    friend class ChannelPool; // 友元目的：允许ChannelPool直接调用reset()管理资源生命周期
public:
    // using ChannelPtr = std::shared_ptr<Channel>;
    using EventCallback = std::function<void()>;
    Channel(int fd);
    ~Channel();
    void closeChannel();
    // 事件回调函数的调用接口
    void handleEvents();
    // 设置和获取Channel的有效性
    bool isValid() { return isValid_; };
    void setValid(bool valid) { isValid_ = valid; };
    // 获取和设置文件描述符
    int  getFd() { return fd_; };
    void setFd(int fd) { fd_ = fd; };
    // 获取和设置正在监听的事件
    int  getEvents() { return events_; };
    void setEvents(int events) { events_ = events; };
    // 设置返回的就绪事件
    void setRetEvents(int retEvents) { retEvents_ = retEvents; };

    // 设置回调函数
    void set_read_handler(EventCallback&& cb) { readCallback_ = std::move(cb); };
    void set_write_handler(EventCallback&& cb) { writeCallback_ = std::move(cb); };
    // void set_update_handler(EventCallback&& cb){updateCallback_ = std::move(cb);};
    void set_close_handler(EventCallback&& cb) { closeCallback_ = std::move(cb); };
    void set_error_handler(EventCallback&& cb) { errorCallback_ = std::move(cb); };
    // 获取连接的总数
    // static int get_channel_count() { return channel_count_; };
private:
    int                 fd_;            // Channel的fd         
    int                 events_;        // Channel正在监听的事件（或者说感兴趣的事件）  
    int                 retEvents_;    // 返回的就绪事件
    bool                isValid_;     // Channel是否有效

    EventCallback       readCallback_;   // 读事件的回调函数
    EventCallback       writeCallback_;  // 写事件的回调函数
    // EventCallback       updateCallback_; // 更新事件的回调函数
    EventCallback       errorCallback_;  // 错误事件的回调函数
    EventCallback       closeCallback_;  // 关闭事件的回调函数

};

using ChannelPtr = std::shared_ptr<Channel>;

// 新增内存池类声明
class ChannelPool {
public:

    static ChannelPool& instance() {
        // 静态局部变量的初始化只会在第一次调用该函数时执行一次
        static ChannelPool pool;
        return pool;
    }

    ChannelPtr acquire(int fd);
    /*
    【注意】 release 方法接受的是 ChannelPtr。如果外部还持有这个 ChannelPtr 的其他副本，release 执行后，虽然对象回到了池中且 fd 被关闭，但如果外部副本后续尝试使用这个 Channel 可能会有问题。
    */
    void release(ChannelPtr channel);

private:
    ChannelPool();
    ~ChannelPool();

    std::mutex mutex_;
    std::vector<ChannelPtr> pool_;
    const size_t INIT_POOL_SIZE = 100;
};
